#include <modelo.h>
//#ifdef DEBUG
#include <cstdio>
//#endif
#include <constantes.h>
#include <globales.h> 
#include <stdlib.h>
#include <cassert>
#include <RWLock.h>

Modelo::Modelo(int njugadores, int tamtablero, int tamtotalbarcos){
	max_jugadores = njugadores;
	tamanio_tablero = tamtablero;
	tamanio_total_barcos = tamtotalbarcos;
	
	this->jugadores = new Jugador*[max_jugadores];
	this->eventos = new std::queue<Evento>[max_jugadores];
	this->tiros = new Tiro[max_jugadores];
	for (int i = 0; i < max_jugadores; i++) {
		this->jugadores[i] = NULL;
	}
	this->cantidad_jugadores = 0;
	this->jugadores_listos = 0;
	this->jugando = SETUP;

	locksJugadores = std::vector<RWLock>(njugadores);
	locksEventos = std::vector<RWLock>(njugadores);
	
	for (int i = 0; i < max_jugadores; i++) {
		RWLock l_jug;
		RWLock l_ev; 
		locksJugadores[i] = l_jug;
		locksEventos[i] = l_ev;
	}

	//printf("->se creo el modelo\n");
}

Modelo::~Modelo() {
	for (int i = 0; i < max_jugadores; i++) {
		if (this->jugadores[i] != NULL) {
			delete this->jugadores[i];
		}
	}
	delete[] this->jugadores;
	delete[] this->tiros;
	delete[] this->eventos;

	//printf("->se destruyo el modelo\n");
}

/** Registra un nuevo jugador en la partida */
int Modelo::agregarJugador(std::string nombre) {
	//printf("->dentro de agregarJugador()\n");
	lockJugando.rlock();
	if (this->jugando != SETUP){
		lockJugando.runlock();
		return -ERROR_JUEGO_EN_PROGRESO;
	}
	//lockJugando.runlock(); -> Si lo ponemos aca, alguien puede cambiarlo antes que agregue el jugador(?)
	int nuevoid = 0;

	wLockear(locksJugadores);

	for (nuevoid = 0; nuevoid < max_jugadores && this->jugadores[nuevoid] != NULL; nuevoid++);
	
	if (this->jugadores[nuevoid] != NULL){ 
		wUnlockear(locksJugadores);
		lockJugando.runlock();
		return -ERROR_MAX_JUGADORES;
	}
	this->jugadores[nuevoid] = new Jugador(nombre);
	wUnlockear(locksJugadores);

	lockCantJugadores.wlock();
	this->cantidad_jugadores++;
	lockCantJugadores.wunlock();

	//printf("->salgo de agregarJugador()\n");
	lockJugando.runlock();
	return nuevoid;
}

/** Intenta agregar un nuevo bote para el jugador indicado. 
	Si tiene exito y todos los jugadores terminaron lanza la rutina @Modelo::empezar
	Sino quita todos los barcos del usuario.
*/
error Modelo::ubicar(int t_id, int * xs, int *  ys, int tamanio) {
	//printf("->dentro de ubicar()\n");
	lockJugando.rlock();
	if (this->jugando != SETUP){
		lockJugando.runlock();
		return -ERROR_JUEGO_EN_PROGRESO;
	}
	lockJugando.runlock();

	locksJugadores[t_id].wlock();
	if (this->jugadores[t_id] == NULL){ 
		locksJugadores[t_id].wunlock();
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	int retorno = this->jugadores[t_id]->ubicar(xs, ys, tamanio);
	locksJugadores[t_id].wunlock();

	if (retorno != ERROR_NO_ERROR){
	//	printf("->voy a borrar_barcos()\n");
		this->borrar_barcos(t_id);
	}
	//Si el jugador esta listo
	locksJugadores[t_id].rlock();
	if (retorno == ERROR_NO_ERROR && this->jugadores[t_id]->listo()) {
		locksJugadores[t_id].runlock();
		lockJugadoresListos.wlock();	
		this->jugadores_listos++;
		//Si ya estan this->jugadores_listoslistos todos los jugadores
	//	printf("->Cantidad de jugador: %d, y max cantiad: %d",  this->jugadores_listos,max_jugadores );
		if(this->jugadores_listos == max_jugadores) {
	//		printf("->libero el juego: ubicar()\n");
			//REVISAR SI ESTO ES LO Q NO ANDA
			lockJugadoresListos.wunlock();
			this->empezar();
	//		printf("->Empiezo ajugar: ubicar()\n");
		}else{
			lockJugadoresListos.wunlock();
		}
	}else{
		locksJugadores[t_id].runlock();
	}
	//printf("->salgo de ubicar()\n");
	return retorno;
}

/** Quita todos los barcos del usuario */
error Modelo::borrar_barcos(int t_id) {
	//printf("->dentro de borrar_barcos()\n");
	lockJugando.rlock();
	if (this->jugando != SETUP){
		lockJugando.runlock();
		return -ERROR_JUEGO_EN_PROGRESO;
	}
	lockJugando.runlock();
	locksJugadores[t_id].wlock();
	if (this->jugadores[t_id] == NULL){ 
		locksJugadores[t_id].wunlock();
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	
	error e = this->jugadores[t_id]->quitar_barcos();
	locksJugadores[t_id].wunlock();
	//printf("->salgo de borrar_barcos()\n");
	return e;
}

/** Comienza la fase de tiros
*/
error Modelo::empezar() {
	//printf("->entro de empezar()\n");
	lockJugando.rlock();
	//printf("->->pase lockJugando.rlock()\n");
	if (this->jugando != SETUP){
		lockJugando.runlock();
	//	printf("->->pase lockJugando.runlock() != SETUP\n");
		return -ERROR_JUEGO_EN_PROGRESO;
	}
	lockJugando.runlock();
	//printf("->->pase lockJugando.runlock()\n");

	for (int i = 0; i < max_jugadores; i++) {
		locksJugadores[i].rlock();
	//	printf("->->pase locksJugadores[%d].rlock()\n", i);
		if (this->jugadores[i] != NULL) {
			locksJugadores[i].runlock();
	//		printf("->->pase locksJugadores[%d].runlock() en if\n", i);
			//Helen Evento evento(0, i, 0, 0, EVENTO_START);
			locksEventos[i].wlock();
	//		printf("->->pase locksEventos[%d].wlock() en if\n", i);
			Evento evento(0, i, 0, 0, EVENTO_START); 
			this->eventos[i].push(evento);
			locksEventos[i].wunlock();
	//		printf("->->pase locksEventos[%d].wunlock() en if\n", i);
		} else {
			locksJugadores[i].runlock();
	//		printf("->->pase locksJugadores[%d].runlock() en else\n", i);
		}
	//	printf("->->pase i:%d\n", i);
	}
	//printf("->->sali del for\n");

	lockJugando.wlock();
	//printf("->->pase lockJugando.wlock()\n");
	this->jugando = DISPAROS;
	lockJugando.wunlock();
	//printf("->->pase lockJugando.wunlock()\n");
	return ERROR_NO_ERROR;
	
	//printf("->salgo de empezar()\n");
}

/** LLamado al finalizar la partida.
	Se marca el juego como terminado y se le notifica a todos los participantes */
error Modelo::finalizar() {
	//printf("->dentro de finalizar()\n");
	//Enviar un evento a todos avisando que termino.
	lockJugando.rlock();
	//printf("->->lockJugando.rlock()\n");
	if (this->jugando != DISPAROS){
		lockJugando.runlock();
	//	printf("->->lockJugando.runlock()\n");
		return -ERROR_JUEGO_NO_COMENZADO;
	}
	lockJugando.runlock();
	//printf("->->lockJugando.runlock()\n");

	
	for (int i = 0; i < max_jugadores; i++) {
	//	printf("Entre al for i:%d\n", i);
		
	//	printf("->->locksJugadores[%d].rlock()\n",i);
		if (this->jugadores[i] != NULL) {
			

			locksEventos[i].wlock();
	//		printf("->->locksEventos[%d].wlock()\n",i);
			Evento evento(0, i, 0, 0, EVENTO_END); 
			this->eventos[i].push(evento);
			locksEventos[i].wunlock();
	//		printf("->->locksEventos[%d].wunlock()\n",i);
		}
		
	//	printf("->->locksJugadores[%d].runlock()\n", i);
	}
	//printf("Sali del for\n");
	

	lockJugando.wlock();
	//printf("->->lockJugando.wlock()\n");
	this->jugando = FINALIZADO;
	printf("->->->-> JUEGO FINALIZADO\n");
	lockJugando.wunlock();
	printf("->->->-> PUNTAJES\n");
	printf("->->->-> PUNTAJES\n");
	for(int i = 0; i < max_jugadores; i++) {
		printf("->->->-> Puntaje jugador %d: %d\n", i, this->jugadores[i]->dame_puntaje());
	}
	
	//printf("->->lockJugando.wunlock()\n");
	//printf("->salgo de finalizar()\n");
	return ERROR_NO_ERROR;
}


/** Para poder finalizar correctamente, necesito la confirmación
	de cada jugador de que sabe que terminamos de jugar. */
error Modelo::ack(int s_id){
	//printf("->dentro de ack()\n");
	//Guardarme en cada jugador que termino de jugar.
	locksJugadores[s_id].wlock();
	error e = this->jugadores[s_id]->ack();
	locksJugadores[s_id].wunlock();
	//printf("->salgo de ack()\n");
	return e;
}

bool Modelo::termino() {
	//printf("->entro en termino()\n");
    for(int i = 0; i < max_jugadores; i++){
    	locksJugadores[i].rlock();
        if(!this->jugadores[i]->termino()){
        	locksJugadores[i].runlock();
        	return false;
        }
        locksJugadores[i].runlock();
    }
    //printf("->salgo en termino()\n");
    return true;
}

/** @Deprecated */
error Modelo::reiniciar() {
	//printf("->entro en reiniciar()\n");
	for (int i = 0; i < max_jugadores; i++) {
		locksJugadores[i].wlock();
		if (this->jugadores[i] != NULL) {
			this->jugadores[i]->reiniciar();
			this->tiros[i].reiniciar();
		}
		locksJugadores[i].wunlock();
	}
	lockJugando.wlock();
	this->jugando = SETUP;
	lockJugando.wunlock();
	//printf("->salgo en reiniciar()\n");
	return ERROR_NO_ERROR;
	
}

/** Desuscribir a un jugador del juego */
error Modelo::quitarJugador(int s_id) {
	//printf("->entro en quitarJugador()\n");
	lockJugando.rlock();
	if (this->jugando != SETUP){
		lockJugando.runlock();
		return -ERROR_JUEGO_EN_PROGRESO;
	}
	lockJugando.runlock();
	locksJugadores[s_id].wlock();
	if (this->jugadores[s_id] == NULL){ 
		locksJugadores[s_id].wunlock();
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	
	delete this->jugadores[s_id];
	
	this->jugadores[s_id] = NULL;
	locksJugadores[s_id].wunlock();
	//printf("->salgo en quitarJugador()\n");
	return ERROR_NO_ERROR;
}

/** Intentar apuntar a la casilla de otro jugador.
	Solo comienza el tiro si el jugador actual puede disparar 
	y al otro jugador se le puede disparar
	*/
int Modelo::apuntar(int s_id, int t_id, int x, int y, int *eta) {
	//printf("->entro en apuntar()\n");
	lockJugando.rlock();
	if (this->jugando != DISPAROS){
		lockJugando.runlock();
		return -ERROR_JUEGO_NO_COMENZADO;
	}
	lockJugando.runlock();

	if(t_id<s_id){
		locksJugadores[t_id].wlock();
		locksJugadores[s_id].wlock();
	}else if(t_id>s_id){
		locksJugadores[s_id].wlock();
		locksJugadores[t_id].wlock();
	}else{
		locksJugadores[t_id].wlock();
	}

	if (this->jugadores[s_id] == NULL){ 
		if(t_id<s_id){
			locksJugadores[t_id].wunlock();
			locksJugadores[s_id].wunlock();
		}else if(t_id>s_id){
			locksJugadores[s_id].wunlock();
			locksJugadores[t_id].wunlock();
		}else{
			locksJugadores[t_id].wunlock();
		}		
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	if (this->jugadores[t_id] == NULL){ 
		if(t_id<s_id){
			locksJugadores[t_id].wunlock();
			locksJugadores[s_id].wunlock();
		}else if(t_id>s_id){
			locksJugadores[s_id].wunlock();
			locksJugadores[t_id].wunlock();
		}else{
			locksJugadores[t_id].wunlock();
		}	
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	if (! this->jugadores[s_id]->esta_vivo()){
		if(t_id<s_id){
			locksJugadores[t_id].wunlock();
			locksJugadores[s_id].wunlock();
		}else if(t_id>s_id){
			locksJugadores[s_id].wunlock();
			locksJugadores[t_id].wunlock();
		}else{
			locksJugadores[t_id].wunlock();
		}	 
		return -ERROR_JUGADOR_HUNDIDO;
	}

	int retorno = RESULTADO_APUNTADO_DENEGADO;
	if (this->tiros[s_id].es_posible_apuntar()) {
		retorno = this->jugadores[t_id]->apuntar(s_id, x, y);
		if (retorno == RESULTADO_APUNTADO_ACEPTADO) {
			*eta = this->tiros[s_id].tirar(t_id, x, y);
			Evento nuevoevento(s_id, t_id, x, y, CASILLA_EVENTO_INCOMING);
			locksEventos[t_id].wlock();
			this->eventos[t_id].push(nuevoevento);   
			locksEventos[t_id].wunlock();
		}
	}

	if(t_id<s_id){
		locksJugadores[t_id].wunlock();
		locksJugadores[s_id].wunlock();
	}else if(t_id>s_id){
		locksJugadores[s_id].wunlock();
		locksJugadores[t_id].wunlock();
	}else{
		locksJugadores[t_id].wunlock();
	}	
	//printf("->salgo apuntar()\n");
	return retorno;
	
}

/** Obtener un update de cuanto tiempo debo esperar para que se concrete el tiro */
int Modelo::dame_eta(int s_id) {
	//printf("->entro en dame_eta()\n");
	lockJugando.rlock();
	if (this->jugando != DISPAROS){ 
		lockJugando.runlock();
		return -ERROR_JUEGO_NO_COMENZADO;
	}
	lockJugando.runlock();

	locksJugadores[s_id].rlock();
	if (this->jugadores[s_id] == NULL){ 
		locksJugadores[s_id].runlock();
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	
	int eta = this->tiros[s_id].getEta();
	locksJugadores[s_id].runlock();
	//printf("->salgo dame_eta()\n");
	return eta;
}

/** Concretar el tiro efectivamente, solo tiene exito si ya trascurrió el eta.
	y e impacta con algo.*/
int Modelo::tocar(int s_id, int t_id) {
	//printf("->entro en tocar()\n");
	lockJugando.rlock();
	//printf("->->lockJugando.rlock()\n");
	if (this->jugando != DISPAROS){ 
		lockJugando.runlock();
	//	printf("->->lockJugando.runlock()\n");
		return -ERROR_JUEGO_NO_COMENZADO;
	}
	lockJugando.runlock();
	//printf("->->lockJugando.runlock()\n");

	if(t_id<s_id){
	//	printf("->tocar t_id < s_id \n");
		locksJugadores[t_id].wlock();
	//	printf("->->pase locksJugadores[%d].wlock() t_id < s_id \n", t_id);
		locksJugadores[s_id].wlock();
	//	printf("->->pase locksJugadores[%d].wlock() t_id < s_id \n", s_id);
	}else if(t_id>s_id){
	//	printf("->tocar t_id > s_id \n");
		locksJugadores[s_id].wlock();
	//	printf("->->pase locksJugadores[%d].wlock() t_id > s_id \n", t_id);
		locksJugadores[t_id].wlock();
	//	printf("->->pase locksJugadores[%d].wlock() t_id > s_id \n", s_id);
	}else{
	//	printf("->tocar t_id == s_id \n");
		locksJugadores[t_id].wlock();
	//	printf("->->pase locksJugadores[%d].wlock() t_id = s_id \n", t_id);
	}
	
	if (this->jugadores[s_id] == NULL){ 
		if(t_id<s_id){
			locksJugadores[t_id].wunlock();
	//		printf("->->pase jugador inexistente s_id locksJugadores[%d].wunlock() t_id < s_id \n", t_id);
			locksJugadores[s_id].wunlock();
	//		printf("->->pase jugador inexistente s_id locksJugadores[%d].wunlock() t_id < s_id \n", s_id);
		}else if(t_id>s_id){
			locksJugadores[s_id].wunlock();
	//		printf("->->pase jugador inexistente s_id locksJugadores[%d].wunlock() t_id > s_id \n", t_id);
			locksJugadores[t_id].wunlock();
	//		printf("->->pase jugador inexistente s_id locksJugadores[%d].wunlock() t_id > s_id \n", t_id);
		}else{
			locksJugadores[t_id].wunlock();
	//		printf("->->pase jugador inexistente s_id locksJugadores[%d].wunlock() t_id = s_id \n", t_id);
		}	
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	if (this->jugadores[t_id] == NULL){ 
		if(t_id<s_id){
			locksJugadores[t_id].wunlock();
	//		printf("->->pase jugador inexistente t_id locksJugadores[%d].wunlock() t_id < s_id \n", t_id);
			locksJugadores[s_id].wunlock();
	//		printf("->->pase jugador inexistente t_id locksJugadores[%d].wunlock() t_id < s_id \n", t_id);
		}else if(t_id>s_id){
			locksJugadores[s_id].wunlock();
	//		printf("->->pase jugador inexistente t_id locksJugadores[%d].wunlock() t_id > s_id \n", t_id);
			locksJugadores[t_id].wunlock();
	//		printf("->->pase jugador inexistente t_id locksJugadores[%d].wunlock() t_id > s_id \n", t_id);
		}else{
			locksJugadores[t_id].wunlock();
		}
		return -ERROR_JUGADOR_INEXISTENTE;
	}
	
	int retorno = -ERROR_ETA_NO_TRANSCURRIDO;
	if (this->tiros[s_id].es_posible_tocar()) {
		int x = this->tiros[s_id].x;
		int y = this->tiros[s_id].y;
		bool murio = false;
		retorno = this->jugadores[t_id]->tocar(s_id, x, y, &murio);
		if (retorno == EMBARCACION_RESULTADO_TOCADO ||
			retorno == EMBARCACION_RESULTADO_HUNDIDO ||
			retorno == EMBARCACION_RESULTADO_HUNDIDO_M ||
			retorno == EMBARCACION_RESULTADO_AGUA ||
			retorno == EMBARCACION_RESULTADO_AGUA_H
			) {
			
			this->tiros[s_id].estado = TIRO_LIBRE;
			Evento evento(s_id, t_id, x, y, retorno);
			//Evento para el tirado
			locksEventos[t_id].wlock();
	//		printf("->lockEventos[%d].wlock \n", t_id);
			this->eventos[t_id].push(evento);
			locksEventos[t_id].wunlock();
	//		printf("->lockEventos[%d].wunlock \n", t_id);
			//Evento para el tirador
			locksEventos[s_id].wlock();
	//		printf("->lockEventos[%d].wlock \n", s_id);
			this->eventos[s_id].push(evento);
			locksEventos[s_id].wunlock();
	//		printf("->lockEventos[%d].wunlock \n", s_id);
			if(murio){
				lockCantJugadores.wlock();
	//			printf("->lockCantJugadores.wlock \n");
				this->cantidad_jugadores--;
				
				if(this->cantidad_jugadores == 1){
                    printf("Dale viejo!\n");
                    
					this->finalizar(); 
	//				printf("Sali finalizar (volvi a tocar)");
				}
				lockCantJugadores.wunlock();
	//			printf("->lockCantJugadores.wunlock \n");
			}
		}
		if (retorno == EMBARCACION_RESULTADO_HUNDIDO) {
			this->jugadores[s_id]->agregar_puntaje(PUNTAJE_HUNDIDO);
		} else if (retorno == EMBARCACION_RESULTADO_HUNDIDO_M) {
			this->jugadores[s_id]->agregar_puntaje(PUNTAJE_HUNDIDO+PUNTAJE_MISMO_JUGADOR);
		} else if (retorno == EMBARCACION_RESULTADO_TOCADO) {
			this->jugadores[s_id]->agregar_puntaje(PUNTAJE_TOCADO);
		} else if (retorno == EMBARCACION_RESULTADO_AGUA_H) {
			this->jugadores[s_id]->agregar_puntaje(PUNTAJE_MAGALLANES);
		} 
	}

	if(t_id<s_id){
		locksJugadores[t_id].wunlock();
	//	printf("->->pase jugador inexistente locksJugadores[%d].wunlock() t_id < s_id \n", t_id);
		locksJugadores[s_id].wunlock();
	//	printf("->->pase jugador inexistente locksJugadores[%d].wunlock() t_id < s_id \n", s_id);
	}else if(t_id>s_id){
		locksJugadores[s_id].wunlock();
	//	printf("->->pase jugador inexistente locksJugadores[%d].wunlock() t_id > s_id \n", s_id);
		locksJugadores[t_id].wunlock();
	//	printf("->->pase jugador inexistente locksJugadores[%d].wunlock() t_id > s_id \n", t_id);
	}else{
		locksJugadores[t_id].wunlock();
	//	printf("->->pase jugador inexistente locksJugadores[%d].wunlock() t_id = s_id \n", t_id);
	}
	//printf("->salgo tocar()\n");
	return retorno;
}

#ifdef DEBUG
void Modelo::print() {
	printf("MODELO -- NJugadores %d, Jugando %d\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n", this->cantidad_jugadores, this->jugando);
	for (int i = 0; i < max_jugadores; i++) {
		if (this->jugadores[i] != NULL) {
			this->jugadores[i]->print();
			printf( "Tiro: id %d, stamp (%lu, %lu), eta %d, estado %d\n", this->tiros[i]->t_id, this->tiros[i]->stamp.tv_sec, (long unsigned int)this->tiros[i]->stamp.tv_usec, this->tiros[i]->eta, this->tiros[i]->estado);
		}
		printf("\n");
	}
	
	printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
}
#endif

/******* RUTINAS DE EVENTOS  *************/
int Modelo::hayEventos(int s_id) {
	//printf("->entro en hayEventos()\n");
	locksEventos[s_id].rlock();
	int hayEvento = this->eventos[s_id].size() > 0;
	locksEventos[s_id].runlock();
	//printf("->salgo hayEventos()\n");

	return hayEvento;
}

Evento Modelo::dameEvento(int s_id) {
	//printf("->entro en dameEvento()\n");
	assert(this->hayEventos(s_id));
	locksEventos[s_id].wlock();
	Evento retorno = this->eventos[s_id].front();
	this->eventos[s_id].pop();
	locksEventos[s_id].wunlock();
	//printf("->salgo en dameEvento()\n");
    return retorno;
}


/** chequear si hay eventos nuevos para un jugador */
Evento Modelo::actualizar_jugador(int s_id) {
	//printf("->entro en actualizar_jugador()\n");
	// Los locks se piden dentro de tocar
	int tocado = this->tocar(s_id, this->tiros[s_id].t_id);
    if (this->hayEventos(s_id) > 0) {
    	Evento retorno = this->eventos[s_id].front();
    	locksEventos[s_id].wlock();
		this->eventos[s_id].pop();
		locksEventos[s_id].wunlock();
	//	printf("->salgo en actualizar_jugador()\n");
		return retorno;
    } else {
    	//printf("->salgo en actualizar_jugador()\n");
		return Evento(s_id, -1, 0, 0, -tocado);
	}
}

void Modelo::wLockear(std::vector<RWLock> vector){
	//printf("->entro en wLockear()\n");
	for (int i = 0; i < max_jugadores;i++){
		vector[i].wlock();
	}	
	//printf("->salgo en wLockear()\n");

}

void Modelo::wUnlockear(std::vector<RWLock> vector){
	//printf("->entro en wUnlockear()\n");
	for (int i = 0; i < max_jugadores;i++){
		vector[i].wunlock();
	}	
	//printf("->salgo en wUnlockear()\n");
}

void Modelo::rLockear(std::vector<RWLock> vector){
	//printf("->entro en rLockear()\n");
	for (int i = 0; i < max_jugadores;i++){
		vector[i].rlock();
	}	
	//printf("->salgo en rLockear()\n");

}

void Modelo::rUnlockear(std::vector<RWLock> vector){
	//printf("->entro en rUnlockear()\n");
	for (int i = 0; i < max_jugadores;i++){
		vector[i].runlock();
	}	
	//printf("->salgo en rUnlockear()\n");
}
